Accounting systems may process transactions. Transactions may be associated with applications including, for example, purchase order applications, sales order applications, accounts receivables, accounts payable, and so on. Each application may have its own transaction type. The transaction type may include a number of fields. Some fields may be identifier fields (e.g., project number, purchase order number, client identifier, period) while other fields may be amount fields (e.g., sales price, sales quantity, discount percentage). An application writes to a central general ledger through an application (e.g., sub-ledger accounting (SLA) application). An SLA logic determines to which account a transaction is to be posted based, at least in part, on the fields in the transaction. The transaction is then posted to the central general ledger with the account, amount, and period. Applications may have their own summarization ledger. In a summarization ledger, fields of interest are stored along with the summed up amount fields. New transactions from the application are posted to the summarization ledger where they update amounts in fields of interest associated with the transactions. The general ledger may in turn be used to produce documents including a balance sheet, an income statement, and so on. Thus, transaction information provided from an application, which may also be referred to as a sub-ledger, is collected and processed by an SLA, and then deposited into various destinations including, for example, a general ledger, a balance sheet, and so on.
The SLA may be a rules-based accounting logic that provides consistent accounting treatment to transactions created across different applications. The SLA may provide a common data model and repository for subsystem accounting activity. Conventionally, when a transaction was processed from a sub-ledger through the SLA into a ledger, that transaction was restricted from being changed due, for example, to issues with downstream reconciliation. Thus, once transactional data was interfaced outside a subledger, the source transaction could not be easily changed, if it could be changed at all. However, transactions may have included errors, omissions, and so on. Conventionally, a follow-on application level transaction may have been produced to correct the error or omission. For example, a first transaction may have reported a purchase order for ten units at $100 apiece. However, the actual purchase order quantity may have been for twenty units at $125 apiece. Conventionally, to remedy the mistake, a second application level transaction for the ten additional units may have been generated. Then, another transaction for all twenty units reconciling the additional $25 apiece may have been generated. In another conventional example, a replacement transaction for the correct quantity and the correct amount may have been provided after the original transaction was “backed out” or deleted from the system. Backing out or deleting a transaction may have been difficult because a single transaction may have included several fields that impacted several other fields (e.g., spreadsheet columns, ledger columns) in several other locations. For example, an SLA may have automatically created multiple simultaneous accounting records for a single transaction in different ledgers.